package Dao;


import Entidade.*;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.swing.JOptionPane;

public class UserDAO extends GenericDAO{
    
    
    public void addUser(String nome, String login, String senha) throws SQLException, BadPaddingException, NoSuchPaddingException, IllegalBlockSizeException, InvalidKeyException, NoSuchAlgorithmException, InvalidAlgorithmParameterException{
        System.out.println(senha);
        String senhaCriptografada = PwDSM.encrypt(senha);
        System.out.println(senhaCriptografada);
        String query = "EXEC dbo.SP_CadastrarUsuario ?, ?, ?"; //nome, login, senha
        executeCommand(query, nome, login, senhaCriptografada);
    }
    
    public boolean validaLogon(String loginUsuario, String senhaUsuario) throws SQLException{
        boolean toReturn = false;
        String senha = "";
        try {
            senha = PwDSM.encrypt(senhaUsuario);
        } catch (BadPaddingException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NoSuchPaddingException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalBlockSizeException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InvalidKeyException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NoSuchAlgorithmException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InvalidAlgorithmParameterException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        }
        ResultSet rs = executeQuery("SELECT * FROM USUARIOS WHERE LOGIN=? AND SENHA = ? AND STATUS = 0", loginUsuario, senha);
        if (rs.next()){
            toReturn = true;
        }
        rs.close();
        return toReturn;
    }

    
    
    public void alteraSenha(String loginUsuario, String novaSenha) throws SQLException{
        String senha = "";
        try {
            senha = PwDSM.encrypt(novaSenha);
        } catch (BadPaddingException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NoSuchPaddingException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalBlockSizeException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InvalidKeyException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NoSuchAlgorithmException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InvalidAlgorithmParameterException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        }
        String query = "UPDATE USUARIOS SET SENHA = ? WHERE LOGIN = ?";
        executeCommand(query, senha, loginUsuario);
    }
    
    public Usuario obterDadosUsuario(String loginUsuario) throws SQLException{
        
        ResultSet rs = executeQuery("SELECT ID, NOME, SENHA, STATUS, DT_CRIACAO  FROM dbo.USUARIOS WHERE LOGIN=?", loginUsuario);
        Usuario usuario = new Usuario();
        while (rs.next()){
            usuario.setId(rs.getInt("ID"));
            usuario.setNome(rs.getString("NOME"));
            usuario.setSenha(rs.getString("SENHA"));
            usuario.setStatus(rs.getInt("STATUS"));
            usuario.setDt_criacao(rs.getDate("DT_CRIACAO"));
        }
        usuario.setLogin(loginUsuario);
        rs.close();
        return usuario;
    }
    
    public Caixa obterUltimoCaixa() throws SQLException{
        Caixa caixa = new Caixa();
        ResultSet rs = executeQuery("EXEC SP_ObterUltimoCaixa");        
        while (rs.next()){
            caixa.setId(rs.getInt("ID"));
            caixa.setData_abertura(rs.getTimestamp("DATA_ABERTURA"));
            caixa.setData_fechamento(rs.getTimestamp("DATA_FECHAMENTO"));
            caixa.setId_usuario(rs.getInt("ID_USUARIO"));
            caixa.setNome(rs.getString("NOME"));
            caixa.setLogin(rs.getString("LOGIN"));
            caixa.setSaldoAnterior(rs.getDouble("SALDO_ANTERIOR"));
            caixa.setTotalSaida(rs.getDouble("TOTAL_SAIDA"));
            caixa.setTotalEntrada(rs.getDouble("TOTAL_ENTRADA"));
            caixa.setTotalPagamento(rs.getDouble("TOTAL_PAGAMENTOS"));
            caixa.setSaldoTotal(rs.getDouble("SALDO_TOTAL"));
            caixa.setStatus(rs.getInt("STATUS"));
            caixa.setTurno(rs.getInt("TURNO"));            
            caixa.setOvertime(rs.getInt("OVERTIME"));
        }      
        rs.close();
        caixa.setListaComposicaoCaixa(obterComposicaoCaixa(caixa.getId()));
        return caixa;        
        
    }
    
    public List<Composicao> obterComposicaoCaixa(int id_caixa) throws SQLException{

        List<Composicao> lista = new ArrayList<Composicao>();

        ResultSet rs = executeQuery("EXEC SP_ObterComposicaoCaixa ?", id_caixa);

        while (rs.next()) {
            Composicao composicao = new Composicao();
            composicao.setQuantidade(rs.getInt("QTDE"));
            composicao.setValor(rs.getDouble("VALOR"));
            lista.add(composicao);
        }
        rs.close();
        return lista;
    }
    
    public boolean verificapermissaoAbrirCaixa() throws SQLException{
        boolean resultado = false;
        int flag = 1;
        String query = "EXEC dbo.SP_VerificaPermissaoAbrirCaixa";
        ResultSet rs = executeQuery(query);
        while(rs.next()){
            flag = rs.getInt("FLAG");
        }
        if (flag == 0) {
            resultado = true;
        }
        return resultado;
    }
    
    
    public void gravarLancamento(Lancamento lancamento) throws SQLException{
        int id_caixa = lancamento.getId_caixa();
        int id_tipo_lancamento = lancamento.getId_tipo_lancamento();
        int id_praca = lancamento.getId_praca();
        String observacao = lancamento.getObservacao();

        //Grava o Lancamento e retorna o ID referente.
        int id_lancamento = 0;
        String query = "EXEC SP_GravarLancamento ?, ?, ?, ?";
        ResultSet rs = executeQuery(query, id_caixa, id_tipo_lancamento, id_praca, observacao);
        while (rs.next()) {
            id_lancamento = rs.getInt("ID_LANCAMENTO");
        }
        rs.close();

        //Grava a composição do lançamento
        gravarComposicaoLancamento(lancamento.getListaComposicao(), id_lancamento, id_caixa);

    }
        
    public void gravarComposicaoLancamento(List<Composicao> listaComposicao, int id_lancamento, int id_caixa) throws SQLException{
        Iterator<Composicao> it = listaComposicao.iterator();            
        while (it.hasNext()) {                
            Composicao c = it.next();            
            double valor = c.getValor();
            int quantidade = c.getQuantidade();
            String query = "EXEC SP_GravarComposicaoLancamento ?, ?, ?, ?";
            executeCommand(query, id_caixa, id_lancamento, valor, quantidade);
        }
    }
    
    public void gerarCaixa(int id_usuario, double saldo_total, List<Composicao> listaComposicao) throws SQLException{
        int id_caixa = 0;
        String query = "EXEC dbo.SP_GerarCaixa ?, ?";
        ResultSet rs = executeQuery(query, id_usuario, saldo_total);
        while (rs.next()) {
            id_caixa = rs.getInt("ID_CAIXA");
        }
        if (id_caixa == 0) {
            JOptionPane.showMessageDialog(null, "Erro ao gerar novo Caixa!");            
        } else {
            gravarComposicaoCaixa(listaComposicao, id_caixa);
        }
        rs.close();
    }
    
    private void gravarComposicaoCaixa(List<Composicao> listaComposicao, int id_caixa) throws SQLException{
        Iterator<Composicao> it = listaComposicao.iterator();            
        while (it.hasNext()) {                
            Composicao c = it.next();
            double valor = c.getValor();
            int quantidade = c.getQuantidade();
            String query = "EXEC SP_GravarComposicaoCaixa ?, ?, ?, ?";
            executeCommand(query, id_caixa, valor, quantidade, 0);
        }
    }    
    
    public void gravarCreditoExterno(CreditoExterno creditoExterno) throws SQLException{        
        int id_caixa = creditoExterno.getId_caixa();
        String observacao = creditoExterno.getObservacao();
        int id_credito_externo = 0;
        String query = "EXEC dbo.SP_GravarCreditoExterno ?, ?";
        ResultSet rs = executeQuery(query, creditoExterno.getId_caixa(), observacao);
        while (rs.next()) {            
            id_credito_externo = rs.getInt("ID_CREDITO_EXTERNO");
        }
        if (id_credito_externo == 0) {
            JOptionPane.showMessageDialog(null, "Erro ao gravar Credito Externo!");
        } else {
            gravarComposicaoCreditoExterno(id_caixa, id_credito_externo, creditoExterno.getListaComposicao());
        }
        rs.close();
    }
    
    private void gravarComposicaoCreditoExterno(int id_caixa, int id_credito_externo, List<Composicao> listaComposicaoCreditoExterno) throws SQLException{
        Iterator<Composicao> it = listaComposicaoCreditoExterno.iterator();
        while (it.hasNext()) {            
            Composicao c = it.next();
            double valor = c.getValor();
            int quantidade = c.getQuantidade();
            String query = "EXEC dbo.SP_GravarComposicaoCreditoExterno ?, ?, ?, ?";
            executeCommand(query, id_caixa, id_credito_externo, valor, quantidade);
        }
    }
    public Saldos consultarSaldos(int id_caixa) throws SQLException{
        Saldos saldos = new Saldos();
        String query = "EXEC SP_ConsultaSaldos ?";
        ResultSet rs = executeQuery(query, id_caixa);
        while (rs.next()) {            
            saldos.setSaldoAnterior(rs.getDouble("SALDO_ANTERIOR"));
            saldos.setTotalSaida(rs.getDouble("TOTAL_SAIDA"));
            saldos.setTotalEntrada(rs.getDouble("TOTAL_ENTRADA"));
            saldos.setTotalPagamento(rs.getDouble("TOTAL_PAGAMENTOS"));
            saldos.setSaldoTotal(rs.getDouble("SALDO_TOTAL"));            
        }
        rs.close();        
        return saldos;
    }
    
    public List<LancamentosEfetuados> consultarLancamentosEfetuados(int id_caixa) throws SQLException{
        List<LancamentosEfetuados> lista = new ArrayList<LancamentosEfetuados>();        
        String query = "EXEC dbo.SP_ObterLancamentosEfetuados ?";
        ResultSet rs = executeQuery(query, id_caixa);
        while (rs.next()) {            
            LancamentosEfetuados lancamentosEfetuados = new LancamentosEfetuados();
            lancamentosEfetuados.setId(rs.getInt("ID"));
            lancamentosEfetuados.setDataHora(rs.getTimestamp("DATA_HORA"));
            lancamentosEfetuados.setTipo(rs.getString("TIPO"));
            lancamentosEfetuados.setDescricao(rs.getString("DESCRICAO"));
            lancamentosEfetuados.setValor(rs.getDouble("VALOR"));
            lancamentosEfetuados.setRetorno(rs.getString("RETORNO"));
            lancamentosEfetuados.setStatus(rs.getString("STATUS"));
            lancamentosEfetuados.setObservacao(rs.getString("OBSERVACAO"));
            lista.add(lancamentosEfetuados);
        }
        rs.close();        
        return lista;
    }
    
    public void estornarLancamentoEfetuado(int id_Caixa, int id_lancamento_efetuado, String tipo) throws SQLException{
        String query = "EXEC dbo.SP_EstornaLancamentoEfetuado ?, ?, ?";
        executeCommand(query, id_Caixa, id_lancamento_efetuado, tipo);
    }
    
    public List<Composicao> consultarComposicaoLancamentoEfetuado(int id_caixa, int id_lancamento_efetuado, String tipo) throws SQLException{
        List<Composicao> lista = new ArrayList<Composicao>();        
        String query = "EXEC SP_ConsultarComposicaoLancamentoEfetuado ?, ?, ?";
        ResultSet rs = executeQuery(query, id_caixa, id_lancamento_efetuado, tipo);
        
        while (rs.next()) {            
            Composicao composicao = new Composicao();
            composicao.setQuantidade(rs.getInt("QTDE"));
            composicao.setValor(rs.getDouble("VALOR"));                        
            lista.add(composicao);
        }
        rs.close();        
        return lista;
    }
    
    public List<LancamentosPendentesRetorno> consultarLancamentosPendentesRetorno(int id_caixa) throws SQLException{
        List<LancamentosPendentesRetorno> listaLpr = new ArrayList<LancamentosPendentesRetorno>();
        String query = "EXEC dbo.SP_ConsultarLancamentosPendentesRetorno ?";
        ResultSet rs = executeQuery(query, id_caixa);
        while (rs.next()) {            
            LancamentosPendentesRetorno lpr = new LancamentosPendentesRetorno();
            lpr.setId(rs.getInt("ID"));
            lpr.setDescricao(rs.getString("DESCRICAO"));
            lpr.setValor(rs.getDouble("VALOR"));
            lpr.setPraca(rs.getString("PRACA"));
            lpr.setData(rs.getTimestamp("DATA_HORA"));
            listaLpr.add(lpr);
        }
        rs.close();
        return listaLpr;
    }

    public List<PagamentosPendentesMalote> consultarPagamentosPendentesMalote(int id_caixa) throws SQLException{
        List<PagamentosPendentesMalote> listaPpm = new ArrayList<PagamentosPendentesMalote>();
        String query = "EXEC dbo.SP_ConsultarPagamentosPendentesMalote ?";
        ResultSet rs = executeQuery(query, id_caixa);
        while (rs.next()) {            
            PagamentosPendentesMalote ppm = new PagamentosPendentesMalote();
            ppm.setId(rs.getInt("ID"));
            ppm.setDescricao(rs.getString("DESCRICAO"));
            ppm.setValor(rs.getDouble("VALOR"));
            listaPpm.add(ppm);
        }
        rs.close();
        return listaPpm;
    }    
    
    
    public void gravarLancamentoRetorno(LancamentoRetorno lc) throws SQLException{
        int id_caixa = lc.getId_caixa();
        int id_lancamento = lc.getId_lancamento();
        String observacao = lc.getObservacao();
        List<Composicao> listaComposicao = lc.getListaComposicao();
        int id_lancamento_retorno = 0;
        
        String query = "EXEC dbo.SP_GravarLancamentoRetorno ?, ?, ?";        
        ResultSet rs = executeQuery(query, id_caixa, id_lancamento, observacao);
        while (rs.next()) {            
            id_lancamento_retorno = rs.getInt("ID_LANCAMENTO_RETORNO");
        }
        rs.close();
        
        if (id_lancamento_retorno == 0) {
            JOptionPane.showMessageDialog(null, "Erro ao gravar Lançamento Retorno!");
        } else {
            gravarComposicaoLancamentoRetorno(id_caixa, id_lancamento_retorno, listaComposicao);
        }
    }
    
    private void gravarComposicaoLancamentoRetorno(int id_caixa, int id_lancamento_retorno, List<Composicao> listaComposicao) throws SQLException{
        Iterator<Composicao> it = listaComposicao.iterator();
        String query = "EXEC dbo.SP_GravarComposicaoLancamentoRetorno ?, ?, ?, ?";
        while (it.hasNext()) {
            Composicao c = it.next();
            double valor = c.getValor();
            int qtde = c.getQuantidade();            
            executeCommand(query, id_caixa, id_lancamento_retorno, valor, qtde);
        }        
    }
    
    public List<Transportadora> carregarTransportadoras() throws SQLException{
        List<Transportadora> lista = new ArrayList<Transportadora>();
        String query = "SELECT ID, NOME FROM dbo.TRANSPORTADORA WHERE STATUS = 0";
        ResultSet rs = executeQuery(query);
        while (rs.next()) {            
            Transportadora t = new Transportadora();
            t.setId(rs.getInt("ID"));
            t.setNome(rs.getString("NOME"));
            lista.add(t);
        }
        rs.close();
        return lista;
    }
    
    public List<ContaCorrente> carregarContaCorrente() throws SQLException{
        List<ContaCorrente> lista = new ArrayList<ContaCorrente>();
        String query = "SELECT ID, DESCRICAO FROM dbo.CONTA_CORRENTE WHERE STATUS = 0";
        ResultSet rs = executeQuery(query);
        while (rs.next()) {            
            ContaCorrente cc = new ContaCorrente();
            cc.setId(rs.getInt("ID"));
            cc.setDescricao(rs.getString("DESCRICAO"));
            lista.add(cc);
        }
        rs.close();
        return lista;
    }
    
    public void gravarSangria(Sangria sangria) throws SQLException{
        int idCaixa = sangria.getId_caixa();
        int guia = sangria.getGuia();
        int malote = sangria.getMalote();
        String contaCorrente = sangria.getContaCorrente();
        String transportadora = sangria.getTransportadora();
        double valor = sangria.getValor();
        String observacao = sangria.getObservacao();
        List<Composicao> listaComposicaoSangria = sangria.getListaComposicaoSangria();
        
        String query = "EXEC dbo.SP_GravarSangria ?, ?, ?, ?, ?, ?, ?";
        ResultSet rs = executeQuery(query, idCaixa, guia, malote, contaCorrente, transportadora, valor, observacao);
        
        int idSangria = 0;
        
        while (rs.next()) {
            idSangria = rs.getInt("ID_SANGRIA");
        }
        
        rs.close();
        
        if (idSangria == 0) {
            JOptionPane.showMessageDialog(null, "Erro ao gravar Sangria!");
        } else{
            gravarComposicaoSangria(idCaixa, idSangria, listaComposicaoSangria);
        }
    }
    
    private void gravarComposicaoSangria(int idCaixa, int idSangria, List<Composicao> listaComposicaoSangria) throws SQLException{
        Iterator<Composicao> it = listaComposicaoSangria.iterator();
        String query = "EXEC dbo.SP_GravarComposicaoSangria ?, ?, ?, ?";
        while (it.hasNext()) {            
            Composicao c = it.next();
            double valor = c.getValor();
            int qtde = c.getQuantidade();
            executeCommand(query, idCaixa, idSangria, valor, qtde);
        }
    }
    
    public int atualizarOvertime() throws SQLException{
        int overtime = 0;
        ResultSet rs = executeQuery("EXEC SP_ObterUltimoCaixa");        
        while (rs.next()){            
            overtime = rs.getInt("OVERTIME");
        }      
        rs.close();
        return overtime;
    }
    
    public void fecharCaixa(int id_caixa) throws SQLException{
        String query = "EXEC dbo.SP_EfetuarFechamentoCaixa ?";
        executeCommand(query, id_caixa);
    }
    
    public Caixa efetuarAberturaCaixa(int id_usuario) throws SQLException{
        Caixa caixa = new Caixa();
        String query = "EXEC dbo.SP_EfetuarAberturaCaixa ?";
        ResultSet rs = executeQuery(query, id_usuario);
        while (rs.next()) {            
            caixa.setId(rs.getInt("ID"));
            caixa.setData_abertura(rs.getTimestamp("DATA_ABERTURA"));
            caixa.setId_usuario(rs.getInt("ID_USUARIO"));
            caixa.setNome(rs.getString("NOME"));
            caixa.setLogin(rs.getString("LOGIN"));
            caixa.setSaldoAnterior(rs.getDouble("SALDO_ANTERIOR"));
            caixa.setTotalSaida(rs.getDouble("TOTAL_SAIDA"));
            caixa.setTotalEntrada(rs.getDouble("TOTAL_ENTRADA"));
            caixa.setTotalPagamento(rs.getDouble("TOTAL_PAGAMENTOS"));
            caixa.setSaldoTotal(rs.getDouble("SALDO_TOTAL"));
            caixa.setStatus(rs.getInt("STATUS"));
            caixa.setTurno(rs.getInt("TURNO"));
            caixa.setOvertime(rs.getInt("OVERTIME"));
        }
        rs.close();        
        caixa.setListaComposicaoCaixa(obterComposicaoCaixa(caixa.getId()));
        return caixa;
    }
    
    public List<TipoPagamento> carregarTipoPagamento() throws SQLException{
        List<TipoPagamento> listaTipoPagamento = new ArrayList<TipoPagamento>();        
        String query = "SELECT ID, DESCRICAO FROM dbo.TIPO_PAGAMENTO WHERE STATUS = 0";
        ResultSet rs = executeQuery(query);
        while (rs.next()) {            
            TipoPagamento tp = new TipoPagamento();
            tp.setId(rs.getInt("ID"));
            tp.setDescricao(rs.getString("DESCRICAO"));
            listaTipoPagamento.add(tp);
        }
        rs.close();        
        return listaTipoPagamento;
    }
    
    public void gravarPagamento(Pagamento p) throws SQLException{
        int idcaixa = p.getIdcaixa();
        String tipoPagamento = p.getTipoPagamento();
        String observacao = p.getObservacao();
        List<Composicao> listaComposicao = p.getListaComposicao();
        
        int idPagamento = 0;
        
        String query = "EXEC dbo.SP_GravarPagamento ?, ?, ?";
        ResultSet rs = executeQuery(query, idcaixa, tipoPagamento, observacao);
        while (rs.next()) {
            idPagamento = rs.getInt("ID_PAGAMENTO");
        }
        if (idPagamento == 0) {
            JOptionPane.showMessageDialog(null, "Erro ao obter o ID_PAGAMENTO");            
        } else {
            gravarComposicaoPagamento(idcaixa, idPagamento, listaComposicao);
        }
    }
    
    private void gravarComposicaoPagamento(int id_caixa, int id_pagamento, List<Composicao> listaComposicao) throws SQLException{
        String query = "EXEC SP_GravarComposicaoPagamento ?, ?, ?, ?";
        Iterator<Composicao> it = listaComposicao.iterator();
        while (it.hasNext()) {            
            Composicao c = it.next();
            double valor = c.getValor();
            int qtde = c.getQuantidade();
            executeCommand(query, id_caixa, id_pagamento, valor, qtde);            
        }        
    }
    
    public void gravarPagamentoMalote(PagamentoMalote pm) throws SQLException{
        int idcaixa = pm.getIdcaixa();
        int[] idPagamento = pm.getIdPagamento();
        int guia = pm.getGuia();
        int malote = pm.getMalote();
        String contaCorrente = pm.getContaCorrente();
        String transportadora = pm.getTransportadora();
        double valor = pm.getValor();        
        String observacao = pm.getObservacao();
        List<Composicao> listaComposicao = pm.getListaComposicao();
        
        int idMalote = 0;
        
        String query = "EXEC dbo.SP_GravarPagamentoMalote ?, ?, ?, ?, ?, ?, ?";
        ResultSet rs = executeQuery(query, idcaixa, guia, malote, contaCorrente, transportadora, valor, observacao);
        while (rs.next()) {
            idMalote = rs.getInt("ID_MALOTE");
        }
        if (idMalote == 0) {
            JOptionPane.showMessageDialog(null, "Erro ao obter o ID_PAGAMENTO");            
        } else {
            query = "UPDATE dbo.PAGAMENTOS SET GERADO_MALOTE = 1, ID_MALOTE = ? WHERE ID = ?";
            for (int i = 0; i < idPagamento.length; i++) {
                System.out.println(i + " : " + idPagamento[i]);
                executeCommand(query, idMalote, idPagamento[i]);
            }            
            gravarComposicaoPagamentoMalote(idcaixa, idMalote, listaComposicao);
        }
    }
    
    private void gravarComposicaoPagamentoMalote(int idCaixa, int idMalote, List<Composicao> listaComposicao) throws SQLException{
        String query = "EXEC dbo.SP_GravarComposicaoPagamentoMalote ?, ?, ?, ?";
        Iterator<Composicao> it = listaComposicao.iterator();
        while (it.hasNext()) {            
            Composicao c = it.next();
            double valor = c.getValor();
            int qtde = c.getQuantidade();
            executeCommand(query, idCaixa, idMalote, valor, qtde);            
        }        
    }    
    
    
}